package com.lms.stream;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.Optional;
import java.util.stream.Stream;

/**
 * @Author: 李孟帅
 * @CreateTime: 2020-07-02 07:51
 * @Description:
 */
public class StreamDemo {
    public static void main(String[] args) {
        Integer[] ints = {9, 2, 3, 4, 7, 5, 8, 6, 1, 5};
//        返回其元素是指定值的顺序排序流。
        Stream<Integer> stream = Stream.of(ints);
//        对此流的每个元素执行操作。
//        stream.forEach(System.out::print);
//        返回此流的所有元素是否与提供的谓词匹配。 false，
//        boolean b = stream.allMatch(num -> num > 8);
//        返回此流的任何元素是否与提供的谓词匹配。true
//        boolean b1 = stream.anyMatch(num -> num > 8);
//        返回此流中的元素数。
//        long count = stream.count();
//        去重
//        stream.distinct().forEach(System.out::print);
//        返回由与此给定谓词匹配的此流的元素组成的流。过滤
//        stream.filter(num->num>5).forEach(System.out::print);
//        返回描述流的一些元素的Optional如果流为空，则返回一个空的Optional 。这个操作的行为显然是不确定的; 可以自由选择流中的任何元素。 这是为了允许并行操作中的最大性能; 成本是同一来源上的多次调用可能不会返回相同的结果。 （如果需要稳定的结果，请改用findFirst() ）
//        Optional<Integer> any = stream.findAny();
//        返回描述此流的第一个元素的Optional如果流为空，则返回一个空的Optional 。
//        Optional<Integer> first = stream.findFirst();
//        返回由给定函数应用于此流的元素的结果组成的流。
//        Stream<String> stringStream = stream.map(num -> num + "元素");
//        返回一个 DoubleStream ，其中包含将给定函数应用于此流的元素的结果。
//        stream.mapToDouble(Integer::doubleValue).forEach(System.out::println);
//        返回由此流的元素组成的流，截短长度不能超过 maxSize 。
//        Stream<Integer> limit = stream.limit(2);
//        在丢弃流的第一个 n元素后，返回由该流的 n元素组成的流。
//        Stream<Integer> skip = stream.skip(2);
//        实现分页操作
//        stream.skip(2).limit(2).forEach(System.out::println);
//        返回由此流的元素组成的流，根据自然顺序排序。
//        Stream<Integer> sorted = stream.sorted();
//        自定义排序规则
//        Stream<Integer> sorted = stream.sorted(Comparator.comparingInt(n -> -n));
//        最大值 根据提供的 Comparator返回此流的最大元素。
//        Optional<Integer> max = stream.max(Comparator.comparingInt(n -> n));
//        都不匹配，为true
//        boolean b = stream.noneMatch(num -> num > 8);
//        返回由该流的元素组成的流，另外在从生成的流中消耗元素时对每个元素执行提供的操作。主要用来调试
//        stream.peek(System.out::println).findFirst();
//        将每个元素计算转换为流，然后多个流合并在一起，例如：1，2，3.处理后：2，3，4，6，6，9
//        Stream<Integer> integerStream = stream.flatMap(n->Stream.of(n*2,n*3));
//        使用 associative累积函数对此流的元素执行 reduction ，并返回描述减小值的 Optional （如果有）。例如：9+2+3+4+...+5=50
//        Optional<Integer> reduce = stream.reduce((n1, n2) -> {
//            System.out.println("n1:"+n1);
//            System.out.println("n2:"+n2);
//            return n1 + n2;
//        });
        //设置一个初始值
//        System.out.println(stream.reduce(10, (result, n) -> result + n));
        ArrayList<Integer> reduce = stream.reduce(new ArrayList<Integer>(), (list, n) -> {
            if (n > 5) {
                list.add(n);
            }
            return list;
        }, (list1, list2) -> {
            list1.addAll(list2);
            return list1;
        });
        reduce.forEach(System.out::println);

    }
}
